home *** CD-ROM | disk | FTP | other *** search
/ Internet Info 1994 March / Internet Info CD-ROM (Walnut Creek) (March 1994).iso / networking / ip / ka9q / MNetsrc.hqx / Mac TCP_IP Source v.33 / mac_misc.c < prev    next >
Text File  |  1989-03-27  |  6KB  |  319 lines
  1. /* mac_misc.c
  2.  *    This module contains several general classes of routines:
  3.  *
  4.  * 1. various routines doing simple char manipulation that are not part of the LSC
  5.  *    libraries but that the KA9Q main-line code needs.
  6.  * 2. stubs that the KA9Q package uses, but are not implemented on the Mac. Obviously,
  7.  *    there must be no functional requirement for these stubs if we are to just return
  8.  *    without action on the Mac.
  9.  * 3. routines to support a linked-list structure to store a series of strings
  10.  *    (used by the file search code and by the I/O init code).
  11.  * 4. miscellaneous Macintosh routines (like time-related routines)
  12.  *
  13.  */
  14.  
  15. #include <stdio.h>
  16. #include "global.h"
  17. #include "mac.h"
  18.  
  19. #include <time.h>
  20.  
  21. extern struct StdWindowRec *stdiowrec,*logwrec,*trcwrec;
  22.     
  23.  
  24. /* -----------------------------------------*/
  25. /* various simple routines needed elsewhere */
  26. /* -----------------------------------------*/
  27.  
  28. /*
  29.  * MoveIt: this is like a bcopy, but uses pascal string type
  30.  * of data.
  31.  */
  32.  
  33. MoveIt(to,from)
  34. char *to, *from;
  35. {
  36.     int size;
  37.  
  38.     memset(to, 0, 3);
  39.     to[0] = size = strlen(from);
  40.     if ( size <= 0)
  41.     {
  42.         printf("MoveIt: size <= 0 (%d\n", size);
  43.         return;
  44.     }
  45.     to++;
  46.     while( size-- )
  47.         *to++ = *from++;    
  48. }
  49.  
  50. /* Determine the size of a Mac memory block on the heap.
  51.  * This is here because we do not have alloc.c in the Mac version.
  52.  */
  53. long
  54. blksize(blk)
  55.     char *blk;
  56. {
  57.     register long *ptr;
  58.     ptr = (long *) (((long) blk) - 8);
  59.     return(((*ptr - 8) - ((*(char *)ptr) & 15)) & 0x00FFFFFF);
  60. }
  61.  
  62. /* this search routine is used by the telnet support */
  63.  
  64. char *memchr(str, chr, cnt)
  65. char *str;
  66. char chr;
  67. int cnt;
  68. {
  69.     int i;
  70.     char *ptr;
  71.  
  72.     for( ptr = str, i = 0; i < cnt; i++, ptr++) {
  73.         if (*ptr == chr )
  74.             return(ptr);
  75.     }
  76.     return(NULLCHAR);
  77. }
  78.  
  79. char *strtac(s1,s2)
  80.    register char *s1,*s2;
  81.    {
  82.    register char *result=s1;
  83.    register int n = strlen(s2);
  84.    
  85.    while (*s1++)
  86.       ;
  87.    while(--s1>=result)
  88.       *(s1+n)= *s1;
  89.       s1++;
  90.    while (*s2)
  91.       *s1++=*s2++;
  92.    return result;
  93.    }
  94.  
  95.  
  96. /* -----------------------*/
  97. /* unimplemented routines */
  98. /* -----------------------*/
  99.  
  100. /*
  101.  * doshell:  execute a shell for the user
  102.  */
  103.  
  104. doshell()
  105. {
  106.     printf("SHELL is not implemented.\n");
  107. }
  108.  
  109. /* restore: stub */
  110. restore()
  111. {}
  112.  
  113. /* stxrdy: stub */
  114. stxrdy()
  115. {return(1);}
  116.  
  117. /* disable: stub */
  118. disable()
  119. {}
  120.  
  121. /* sysreset: stub */
  122. sysreset()
  123. {}
  124.  
  125. /* ------------------*/
  126. /* name-list manager */
  127. /* ------------------*/
  128.  
  129. /*
  130.  * NLadd_name
  131.  * This routine adds an additional name to a list of structures. A success/failure
  132.  * indication is returned for the caller to examine (0=success, -1=failure).
  133.  */
  134.  
  135. int NLadd_name(name,first)
  136. char *name;
  137. struct RemoveIt *first;
  138. {
  139.     struct RemoveIt *rptr;
  140.  
  141. /* get our first entry, traverse list to reach end */
  142.     rptr = first;
  143.     while(rptr->next != NULL ) {
  144.         rptr = rptr->next;
  145.     }
  146.  
  147. /* allocate space for another list entry */
  148.     
  149.     if ( (rptr->next = (struct RemoveIt *)malloc(sizeof (struct RemoveIt)) ) == NULL) {
  150.         printf("Could not allocate memory for structure RemoveIt\n");
  151.         return(-1);
  152.     }
  153.  
  154. /* allocate space for the name */
  155.  
  156.     if ( (rptr->name_ptr = malloc(strlen(name)+1) ) == NULL) {
  157.         rptr->next = NULL;
  158.         printf("Could not allocate memory for %s\n", name);
  159.         return(-1);
  160.     }
  161.  
  162. /* copy the name to the allocated area */
  163.     strcpy(rptr->name_ptr, name);
  164.     
  165. /* jump to last entry on list and initialize */
  166.     rptr = rptr->next;
  167.     rptr->next = NULL;        /* initialize pointer to next entry */
  168.     rptr->name_ptr = NULL;    /* initialize string pointer */
  169.     
  170.     return (0);        /* return success indication */
  171. }
  172.  
  173. /*
  174.  * NLdelete_all
  175.  * This routine deletes all the storage allocated for the list of structures, and leaves
  176.  * the first entry set with a null pointer.
  177.  */
  178.  
  179. int NLdelete_all(first)
  180. struct RemoveIt *first;
  181. {
  182.     struct RemoveIt *rptr;
  183.     struct RemoveIt *next;
  184.  
  185. /* get our first entry, delete string but leave structure with null pointer */
  186.     rptr = first;
  187.     next = rptr->next;
  188.     if (rptr->name_ptr != NULL)
  189.         (void) free(rptr->name_ptr);
  190.     rptr->next = NULL;        /* initialize pointer to next entry */
  191.     rptr->name_ptr = NULL;    /* initialize string pointer */
  192.     
  193. /* now traverse list */
  194.     while(next != NULL) {
  195.         rptr = next;
  196.         next = rptr->next;
  197.         if (rptr->name_ptr != NULL)
  198.             (void) free(rptr->name_ptr);
  199.         (void) free(rptr);
  200.     }
  201.  
  202.     return (0);        /* return success indication */
  203. }
  204.  
  205. /*
  206.  * NLdelete_first
  207.  * This routine deletes the first entry.
  208.  */
  209.  
  210. int NLdelete_first(first)
  211. struct RemoveIt *first;
  212. {
  213.     struct RemoveIt *rptr;
  214.  
  215. /* get our first entry, delete string if there is one */
  216.  
  217.     rptr = first->next;
  218.     if (first->name_ptr != NULL)
  219.         (void)free(first->name_ptr);    /* delete string */
  220.  
  221. /* if there are more structures, copy the next one into the first, then
  222.  * delete the storage of the next one */
  223.  
  224.      if (rptr != NULL) {
  225.         first->next = rptr->next;    /* copy pointers */
  226.         first->name_ptr = rptr->name_ptr;
  227.         (void)free(rptr);            /* delete structure */
  228.     }
  229.     
  230.     return (0);        /* return success indication */
  231. }
  232.  
  233. /*
  234.  * NLreturn_first
  235.  * This routine returns the string pointer in the first entry.
  236.  */
  237.  
  238. char *NLreturn_first(first)
  239. struct RemoveIt *first;
  240. {
  241.  
  242. /* get our first entry, return string pointer component */
  243.  
  244.     return(first->name_ptr);
  245. }
  246.  
  247. /* -----------------------------*/
  248. /* environment or time routines */
  249. /* -----------------------------*/
  250.  
  251. /*
  252.  * clksec: return the amount of time in secs.
  253.  */
  254.  
  255. int32
  256. clksec()
  257. {
  258.     return(time(NULL));
  259. }
  260.  
  261. /* checks the time then ticks and updates ISS */
  262. static unsigned long tickval = 0;
  263. void
  264. check_time()
  265. {
  266.     if(TickCount() > tickval + 6 )
  267.     {
  268.         tickval = TickCount();
  269.         tick();
  270.         (void)iss();
  271.         (void)icmpclk();
  272.     }
  273. }
  274.  
  275. /* get environment: only use within KA9Q is to retrieve the local timezone.
  276.  */
  277.  
  278. char *getenv(str)
  279. char *str;
  280. {
  281.     return(tzname[0]);
  282. }
  283.  
  284. char *strsave( p)
  285. char *p;
  286. {
  287.     char *t;
  288.  
  289.     t=malloc(strlen(p));
  290.     strncpy(t,p,strlen(p));
  291. }
  292.  
  293. void
  294. MacHelp()                /* Enter the Help Facility */
  295. {
  296.     DoHelp("\p","\pKA9Q Internet Software","\pApple Macintosh Version",
  297.         "\p⌐ Copyright 1988, Phil Karn",TRUE,0L);
  298.     DisposeHelp();
  299. }
  300. void
  301. mac_quits()
  302. {
  303. /*    Call Mac cleanup routine */
  304.   iostop();    
  305.   exit(0);
  306. }
  307. void
  308. mac_windows(item,event)
  309. char *item;
  310. EventRecord *event;
  311. {
  312.     if(strcmp(item,"Console") == 0)
  313.         SelectWindow(stdiowrec);
  314.     if(strcmp(item,"Log") == 0)
  315.         SelectWindow(logwrec);
  316.     if(strcmp(item,"Trace") == 0)
  317.         SelectWindow(trcwrec);
  318. }
  319.